package org.jeecg.modules.manage.technology.controller;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.modules.demo.patent.entity.Patent;
import org.jeecg.modules.demo.patent.mapper.PatentMapper;

import org.jeecg.modules.manage.technology.service.ITechnologyService;
import org.jeecg.modules.manage.technology.vo.AnalysisResultVO;
import org.jeecg.modules.manage.technology.vo.AnalysisStatisticsVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @Description: 技术识别分析控制器
 * @Author: jeecg-boot
 * @Date: 2025-11-03
 * @Version: V1.0
 */
@Tag(name = "技术识别分析")
@RestController
@RequestMapping("/technology/analysis")
@Slf4j
public class TechnologyAnalysisController {

    @Autowired
    private ITechnologyService technologyService;

    @Autowired
    private PatentMapper patentMapper;

    /**
     * 统一的专利技术分析接口
     * 支持多种调用方式：
     * 1. 分析所有：不传参数（默认分析所有未处理专利）
     * 2. 分析指定数量：limit=10（分析前10条未处理专利）
     * 3. 分析指定专利：patentIds=id1&patentIds=id2（分析指定ID的专利，可单个或多个）
     *
     * @param limit      限制数量，-1 表示不限制（默认 -1，即分析所有）
     * @param patentIds  专利ID列表（可选），传入后直接查询指定ID
     * @return 处理结果
     */
    @AutoLog(value = "分析专利技术")
    @Operation(summary = "统一的专利技术分析接口", 
               description = "支持：1.全部(默认) 2.指定数量(limit) 3.指定ID列表(patentIds)")
    @PostMapping(value = "/analyze")
    public Result<AnalysisResultVO> analyzePatents(
            @RequestParam(name = "limit", defaultValue = "-1") Integer limit,
            @RequestParam(name = "patentIds", required = false) List<String> patentIds) {
        
        try {
            List<Patent> targetPatentList;
            
            // 场景1：如果指定了专利ID列表，根据ID批量查询
            if (CollUtil.isNotEmpty(patentIds)) {
                // 批量查询专利
                QueryWrapper<Patent> queryWrapper = new QueryWrapper<>();
                queryWrapper.in("id", patentIds);
                targetPatentList = patentMapper.selectList(queryWrapper);
                
                // 检查是否有不存在的ID
                if (targetPatentList.size() != patentIds.size()) {
                    log.warn("部分专利ID不存在，期望{}个，实际查询到{}个", patentIds.size(), targetPatentList.size());
                }
                
                if (CollUtil.isEmpty(targetPatentList)) {
                    return Result.error("指定的专利ID都不存在");
                }
                
                log.info("分析指定的{}个专利", targetPatentList.size());
            }
            // 场景2：根据 limit 查询未处理的专利
            else {
                QueryWrapper<Patent> queryWrapper = new QueryWrapper<>();
                queryWrapper.eq("ai_processed", 0);
                queryWrapper.orderByAsc("create_time");
                
                // limit > 0: 限制数量；limit = -1 或其他: 查询所有
                if (limit != null && limit > 0) {
                    queryWrapper.last("LIMIT " + limit);
                    log.info("开始分析前{}条未处理专利...", limit);
                } else {
                    log.info("开始分析所有未处理专利（limit={}）...", limit);
                }
                
                targetPatentList = patentMapper.selectList(queryWrapper);
            }
            
            // 校验数据
            if (CollUtil.isEmpty(targetPatentList)) {
                return Result.error("没有需要分析的专利数据");
            }
            
            int totalCount = targetPatentList.size();
            log.info("共{}条专利记录，开始逐条分析...", totalCount);
            
            // 批量处理
            int successCount = technologyService.batchAnalyzePatentTechnology(targetPatentList);
            
            // 构建返回结果
            AnalysisResultVO resultVO = new AnalysisResultVO();
            resultVO.setTotalCount(totalCount);
            resultVO.setSuccessCount(successCount);
            resultVO.setFailCount(totalCount - successCount);
            resultVO.setSuccessRate(String.format("%.2f%%", successCount * 100.0 / totalCount));
            
            log.info("分析完成！成功处理{}/{}条专利", successCount, totalCount);
            
            return Result.OK(resultVO);
            
        } catch (Exception e) {
            log.error("分析专利技术失败：{}", e.getMessage(), e);
            return Result.error("分析失败：" + e.getMessage());
        }
    }


    /**
     * 获取分析统计信息
     *
     * @return 统计信息
     */
    @Operation(summary = "获取分析统计信息")
    @GetMapping(value = "/statistics")
    public Result<AnalysisStatisticsVO> getStatistics() {
        try {
            // 统计专利总数
            long totalPatents = patentMapper.selectCount(null);

            // 统计已分析的专利数（有技术关联的专利）
            QueryWrapper<Patent> queryWrapper = new QueryWrapper<>();
            queryWrapper.inSql("id", "SELECT DISTINCT patent_id FROM t_patent_genealogy");
            long analyzedPatents = patentMapper.selectCount(queryWrapper);

            AnalysisStatisticsVO statisticsVO = new AnalysisStatisticsVO();
            statisticsVO.setTotalPatents(totalPatents);
            statisticsVO.setAnalyzedPatents(analyzedPatents);
            statisticsVO.setUnanalyzedPatents(totalPatents - analyzedPatents);
            if (totalPatents > 0) {
                statisticsVO.setAnalyzedRate(String.format("%.2f%%", analyzedPatents * 100.0 / totalPatents));
            } else {
                statisticsVO.setAnalyzedRate("0.00%");
            }

            return Result.OK(statisticsVO);

        } catch (Exception e) {
            log.error("获取统计信息失败：{}", e.getMessage(), e);
            return Result.error("获取统计信息失败：" + e.getMessage());
        }
    }
}

